#include "VTTFFont.h"
#include "VMain.h"



VTTFFont::VTTFFont(void) :
    _font(NULL),
    _loaded(false)
{

}

VTTFFont::~VTTFFont(void)
{
}

bool VTTFFont::load(const std::string& ttf_file_path, int ptsize)
{
    _font = TTF_OpenFont(ttf_file_path.c_str(), ptsize);

    if (_font == NULL)
    {
        SDL_SetError("Load ttf font '%s' error, err reason: %s",
                     ttf_file_path.c_str(),
                     TTF_GetError());
        DEBUG_OUTPUT(SDL_GetError());
        return false;
    }

    return true;
}

bool VTTFFont::bold()
{
    return (TTF_GetFontStyle(_font) & TTF_STYLE_BOLD);
}

void VTTFFont::setBold(bool bold)
{
    int style;
    style = TTF_GetFontStyle(_font);

    if (bold)
    {
        TTF_SetFontStyle(_font, style | TTF_STYLE_BOLD);
    }
    else
    {
        TTF_SetFontStyle(_font, style &~ TTF_STYLE_BOLD);
    }
}
bool VTTFFont::italic()
{
#pragma warning(disable: 4800)
    return (TTF_GetFontStyle(_font) & TTF_STYLE_ITALIC);
#pragma warning(default: 4800)
}
void VTTFFont::setItalic(bool italic)
{
    int style;
    style = TTF_GetFontStyle(_font);

    if (italic)
    {
        TTF_SetFontStyle(_font, style | TTF_STYLE_ITALIC);
    }
    else
    {
        TTF_SetFontStyle(_font, style &~ TTF_STYLE_ITALIC);
    }
}
bool VTTFFont::underline()
{
#pragma warning(disable: 4800)
    return (bool)(TTF_GetFontStyle(_font) & TTF_STYLE_UNDERLINE);
#pragma warning(default: 4800)
}
void VTTFFont::setUnderline(bool underline)
{
    int style;
    style = TTF_GetFontStyle(_font);

    if (underline)
    {
        TTF_SetFontStyle(_font, style | TTF_STYLE_UNDERLINE);
    }
    else
    {
        TTF_SetFontStyle(_font, style & ~TTF_STYLE_UNDERLINE);
    }
}
/*    // invalid in wince
bool VTTFFont::strikeline()
{
    return (TTF_GetFontStyle(_font) & TTF_STYLE_STRIKETHROUGH);
}
void VTTFFont::setStrikeline(bool strikeline)
{
    int style;
    style = TTF_GetFontStyle(_font);
    TTF_SetFontStyle(_font, style | TTF_STYLE_STRIKETHROUGH);
}
*/


int VTTFFont::fontHeight() const
{
    return TTF_FontHeight(_font);
}


char* VTTFFont::fontFamilyName() const
{
    return TTF_FontFaceFamilyName(_font);
}

void VTTFFont::sizeText(const std::string& text, int* w, int* h) const
{
    TTF_SizeUTF8(_font, text.c_str(), w, h);
}

bool VTTFFont::init()
{
    if (!TTF_WasInit())
    {
        return !TTF_Init();
    }

    return true;
}
#define TTF_GBK2UTF8

GLuint VTTFFont::renderText(const std::string& text,
                            unsigned char r,
                            unsigned char g,
                            unsigned char b)
{
    SDL_Surface* text_sfc;
    SDL_Color color;
    color.r = r;
    color.g = g;
    color.b = b;

    text_sfc = TTF_RenderUTF8_Blended(_font,
// #ifdef TTF_GBK2UTF8
//                                       VMain::gbk2utf8(text).c_str(),
// #else
                                      text.c_str(),
// #endif
                                      color);

    if (!text_sfc)
    {
        return INVALID_TEXTURE;
    }

    GLuint texture = VMain::makeSurfaceTexture(text_sfc);

    SDL_FreeSurface(text_sfc);

    return texture;
}
